package com.yunke.common.exception;

import com.yunke.common.result.YunkeResultCode;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.Collection;

/**
 * 云科搭子系统断言工具类
 * 
 * @author yunke
 * @since 1.0.0
 */
public class YunkeAssert {

    private YunkeAssert() {
        // 工具类不允许实例化
    }

    /**
     * 断言表达式为真，否则抛出异常
     *
     * @param expression 表达式
     * @param message    异常信息
     */
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言表达式为真，否则抛出异常
     *
     * @param expression 表达式
     * @param resultCode 结果码
     */
    public static void isTrue(boolean expression, YunkeResultCode resultCode) {
        if (!expression) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言表达式为真，否则抛出异常
     *
     * @param expression 表达式
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void isTrue(boolean expression, YunkeResultCode resultCode, String message) {
        if (!expression) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言表达式为假，否则抛出异常
     *
     * @param expression 表达式
     * @param message    异常信息
     */
    public static void isFalse(boolean expression, String message) {
        if (expression) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言表达式为假，否则抛出异常
     *
     * @param expression 表达式
     * @param resultCode 结果码
     */
    public static void isFalse(boolean expression, YunkeResultCode resultCode) {
        if (expression) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言表达式为假，否则抛出异常
     *
     * @param expression 表达式
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void isFalse(boolean expression, YunkeResultCode resultCode, String message) {
        if (expression) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言对象为null，否则抛出异常
     *
     * @param object  对象
     * @param message 异常信息
     */
    public static void isNull(Object object, String message) {
        if (object != null) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言对象为null，否则抛出异常
     *
     * @param object     对象
     * @param resultCode 结果码
     */
    public static void isNull(Object object, YunkeResultCode resultCode) {
        if (object != null) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言对象为null，否则抛出异常
     *
     * @param object     对象
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void isNull(Object object, YunkeResultCode resultCode, String message) {
        if (object != null) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言对象不为null，否则抛出异常
     *
     * @param object  对象
     * @param message 异常信息
     */
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言对象不为null，否则抛出异常
     *
     * @param object     对象
     * @param resultCode 结果码
     */
    public static void notNull(Object object, YunkeResultCode resultCode) {
        if (object == null) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言对象不为null，否则抛出异常
     *
     * @param object     对象
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void notNull(Object object, YunkeResultCode resultCode, String message) {
        if (object == null) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言字符串不为空，否则抛出异常
     *
     * @param text    字符串
     * @param message 异常信息
     */
    public static void hasText(String text, String message) {
        if (!StringUtils.hasText(text)) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言字符串不为空，否则抛出异常
     *
     * @param text       字符串
     * @param resultCode 结果码
     */
    public static void hasText(String text, YunkeResultCode resultCode) {
        if (!StringUtils.hasText(text)) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言字符串不为空，否则抛出异常
     *
     * @param text       字符串
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void hasText(String text, YunkeResultCode resultCode, String message) {
        if (!StringUtils.hasText(text)) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言字符串为空，否则抛出异常
     *
     * @param text    字符串
     * @param message 异常信息
     */
    public static void noText(String text, String message) {
        if (StringUtils.hasText(text)) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言字符串为空，否则抛出异常
     *
     * @param text       字符串
     * @param resultCode 结果码
     */
    public static void noText(String text, YunkeResultCode resultCode) {
        if (StringUtils.hasText(text)) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言集合不为空，否则抛出异常
     *
     * @param collection 集合
     * @param message    异常信息
     */
    public static void notEmpty(Collection<?> collection, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言集合不为空，否则抛出异常
     *
     * @param collection 集合
     * @param resultCode 结果码
     */
    public static void notEmpty(Collection<?> collection, YunkeResultCode resultCode) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 断言集合不为空，否则抛出异常
     *
     * @param collection 集合
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void notEmpty(Collection<?> collection, YunkeResultCode resultCode, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new YunkeException(resultCode, message);
        }
    }

    /**
     * 断言数组不为空，否则抛出异常
     *
     * @param array   数组
     * @param message 异常信息
     */
    public static void notEmpty(Object[] array, String message) {
        if (ObjectUtils.isEmpty(array)) {
            throw new YunkeException(message);
        }
    }

    /**
     * 断言数组不为空，否则抛出异常
     *
     * @param array      数组
     * @param resultCode 结果码
     */
    public static void notEmpty(Object[] array, YunkeResultCode resultCode) {
        if (ObjectUtils.isEmpty(array)) {
            throw new YunkeException(resultCode);
        }
    }

    /**
     * 直接抛出异常
     *
     * @param message 异常信息
     */
    public static void fail(String message) {
        throw new YunkeException(message);
    }

    /**
     * 直接抛出异常
     *
     * @param resultCode 结果码
     */
    public static void fail(YunkeResultCode resultCode) {
        throw new YunkeException(resultCode);
    }

    /**
     * 直接抛出异常
     *
     * @param resultCode 结果码
     * @param message    异常信息
     */
    public static void fail(YunkeResultCode resultCode, String message) {
        throw new YunkeException(resultCode, message);
    }
} 